home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 4 / Amiga Tools 4.iso / tools / wb-enhancement / madhouse / developer / c-demo / demo_german.c next >
Encoding:
C/C++ Source or Header  |  1996-02-26  |  10.8 KB  |  392 lines
  1. /*    demo_german.c
  2.     Dies ist ein Beispiel-Blanker für Madhouse, mit deutschen Kommentaren.
  3.  
  4.    Hinweisen zum kompilieren des Programms:
  5.     - Vielleicht mag Dein Compiler nicht die <pragma/...>-Includes.
  6.      Dann kannst Du diese Includes evtl. weglassen, oder "pragma" muß ge-
  7.      ändert werden.
  8.     - Dieses Programm kann mit dem MaxonC++ Version 3 problemlos übersetzt
  9.      werden. Für andere Compiler kann eine Anpassung nötig werden.
  10. */
  11.  
  12.  
  13. #include <dos/dos.h>
  14. #include <intuition/intuition.h>
  15. #include <intuition/screens.h>
  16. #include <pragma/graphics_lib.h>
  17. #include <pragma/intuition_lib.h>
  18. #include <pragma/exec_lib.h>
  19. #include <pragma/dos_lib.h>
  20. #include <stdio.h>
  21. #include <stdlib.h>
  22. #include <time.h>
  23. #include <string.h>
  24.  
  25. #define ABNC 0x40
  26. #define ABC  0x80
  27.  
  28.  
  29. /* Prototypen: */
  30. void write_stopblank();
  31. void read_prefs();
  32. void write_error( char *str );
  33.  
  34.  
  35. /* Variablen */
  36. char text[40];
  37. short color, scroll;
  38. time_t start;
  39. short duration_sec=0;
  40. struct Library *IntuitionBase = NULL;
  41. struct Library *GfxBase = NULL;
  42. struct Screen *scr = NULL;
  43. struct Window *win = NULL;
  44. struct Message *msg = NULL;
  45. USHORT DemoPalette[] = {
  46.     0x0000, 0x0FFF
  47. };
  48. struct TextAttr topaz8 = {
  49.     "topaz.font",
  50.     8,
  51.     0,
  52.     0
  53. };
  54.  
  55. /***************************************************************************
  56. ***                          open_all()
  57. ***                 Öffnet alle benötigten Dinge.
  58. ***************************************************************************/
  59.  
  60. BOOL open_all()
  61. {
  62.     IntuitionBase = OpenLibrary("intuition.library",37);
  63.     if( !IntuitionBase ) return FALSE;
  64.     GfxBase = OpenLibrary("graphics.library",37);
  65.     if( !GfxBase ) return FALSE;
  66.  
  67.     /* Einen einfachen LowRes-Screen öffnen. */
  68.     scr = OpenScreenTags(NULL,
  69.           SA_Depth,         1,
  70.           SA_Width,         320,
  71.         SA_Height,        256,
  72.           SA_Font,          &topaz8,
  73.           TAG_DONE);
  74.     if(!scr) return FALSE;
  75.     
  76.     /* Der Mauszeiger verschwindet, wenn man ihm die Farben des Hintergrunds
  77.        gibt: */
  78.     SetRGB4( &scr->ViewPort,17,0,0,0);
  79.     SetRGB4( &scr->ViewPort,18,0,0,0);
  80.     SetRGB4( &scr->ViewPort,19,0,0,0);
  81.     
  82.     win = OpenWindowTags(NULL,
  83.              WA_AutoAdjust,    TRUE,
  84.              WA_NoCareRefresh, TRUE,
  85.              WA_CustomScreen,  scr,
  86.              WA_Flags,         WFLG_RMBTRAP,
  87.              WA_Borderless,    TRUE,
  88.              WA_Activate,      TRUE,
  89.              WA_IDCMP,             IDCMP_MOUSEBUTTONS+IDCMP_RAWKEY,
  90.              TAG_DONE );
  91.     if( !win ) return FALSE;
  92.     
  93.     LoadRGB4( &scr->ViewPort, DemoPalette, 2 );
  94.     
  95.     return TRUE;
  96. }
  97.  
  98. /***************************************************************************
  99. ***                          close_all()
  100. ***             Schließt alles, was wir geöffnet hatten.
  101. ***************************************************************************/
  102.  
  103. void close_all()
  104. {
  105.     /* Diese Anweisung legt den Screen nach hinten. Dies verhindert einen
  106.        nervigen Effekt, wenn der Screen auf einem 68000-Amiga geschlossen
  107.        wird. */
  108.     if( scr )
  109.         ScreenToBack( scr );
  110.     
  111.     /* Wenn etwas schlief lief, müssen wir das Madhouse mitteilen. Aber
  112.        weil man write_error() nur einmal aufrufen darf, benötigen wir
  113.        diese nette if-Konstruktion: */
  114.     
  115.     if( !IntuitionBase ) write_error( "No intuition.lib V37!" );
  116.     else {
  117.         if( !GfxBase ) write_error( "No graphics.lib V37!" );
  118.         else {
  119.             if( !scr ) write_error( "Out of memory: Couldn't open screen.");
  120.             else {
  121.                 if( !win ) write_error( "Out of memory: Couldn't open window.");
  122.             }
  123.         }
  124.     }
  125.     
  126.     /* Jetzt schließen wir alles, was wir öffnen konnten. */
  127.     if( win ) CloseWindow( win );
  128.     if( scr ) CloseScreen( scr );
  129.     if( GfxBase ) CloseLibrary( GfxBase );
  130.     if( IntuitionBase ) CloseLibrary( IntuitionBase );
  131. }
  132.  
  133. /***************************************************************************
  134. ***                              main()
  135. ***            Hier steht nun endlich der richtige Blanker:
  136. ***************************************************************************/
  137.  
  138. void main()
  139. {
  140.     BOOL quit = FALSE;
  141.     BOOL user_quit = FALSE;
  142.     short ypos = 20;
  143.     short direction = 1;
  144.     short oldy;
  145.     
  146.     /* Zuerst lesen wir die Blanker-Einstellungen (aus dem BlankerPrefs-
  147.        Fenster) sowie den Duration-Wert, der angibt, wielange der Blanker
  148.        blanken darf. */
  149.     read_prefs();
  150.     
  151.     /* Jetzt wird die Stopp-Uhr gestartet (zum Überprüfen des Eigen-Abbruchs) */
  152.     start = time(NULL);
  153.     
  154.     /* Screen und Fenster werden geöffnet. */
  155.     if(open_all()) {
  156.         
  157.         /* Je nach Einstellung bekommt der Text eine andere Farbe: */
  158.         switch( color ) {
  159.             case 0:
  160.                 SetRGB4( &scr->ViewPort, 1, 15,0,0 );
  161.                 break;
  162.             case 1:
  163.                 SetRGB4( &scr->ViewPort, 1, 15,15,0 );
  164.                 break;
  165.             case 2:
  166.                 SetRGB4( &scr->ViewPort, 1, 0,0,15 );
  167.         }
  168.         
  169.         /* Text-Parameter: der Text wird geschrieben. */
  170.         SetAPen( win->RPort, 1 );
  171.         Move( win->RPort, 5, ypos );
  172.         Text( win->RPort, text, ( strlen(text) > 38 ? 38 : strlen(text)) );
  173.         
  174.         /* Hauptschleife. */
  175.         while( !quit ) {
  176.             
  177.             /* Wenn Scroll gewählt wurde, muß der Text bewegt werden: */
  178.             if( scroll ) {
  179.                 oldy = ypos;
  180.                 ypos += direction;
  181.                 if( (ypos > 220)  ||  (ypos < 20) ) direction *= -1;
  182.                 
  183.                 ClipBlit(win->RPort, 5, oldy-10, win->RPort, 5, ypos-10, 310, 20, ABNC | ABC );
  184.                 /* Minterme ABNC | ABC -> Rechteck ohne Veränderungen kopieren. */
  185.             }
  186.             
  187.             /* Mausknöpfe oder ein Tastendruck? */
  188.             if( msg = GetMsg(win->UserPort) ) {
  189.                 quit = TRUE;
  190.                 user_quit = TRUE;
  191.                 ReplyMsg( msg );
  192.             }
  193.             
  194.             /* Wenn 'Change Blanker' im Hauptfenster aktiviert wurde
  195.                (duration_sec ist ungleich null) UND wir schon etwas länger
  196.                blanken als erlaubt (difftime(time(NULL),start) > time_counter)
  197.                dann müssen wir schlußmachen. */
  198.             if( duration_sec && difftime(time(NULL),start) > duration_sec )
  199.                 quit = TRUE;
  200.             
  201.             WaitTOF();
  202.         }
  203.         
  204.     }
  205.     
  206.     /* Alles Angeforderte schließen (und vielleicht einen Fehler schreiben): */
  207.     close_all();
  208.     
  209.     /* Wenn unser Blanker durch den Anwender beendet wurde, müssen wir das Mad-
  210.        house mitteilen (sonst würde es [bei aktivertem Change Blanker] den
  211.        nächsten Blanker starten. */
  212.     
  213.     if( user_quit )
  214.         write_stopblank();
  215.     
  216.     /* Und fertig! */
  217. }
  218.  
  219.  
  220. /***************************************************************************
  221. ***                                                                      ***
  222. ***              Funktionen zur Verständigung mit Madhouse               ***
  223. ***                                                                      ***
  224. ***************************************************************************/
  225.  
  226. /* Einige globale Variablen: */
  227.  
  228. char bu[1500];        /* Der Speicherbereich bu[] enthält die gesamte prefs-
  229.                          Datei. */
  230. short bu_seek = 0;    /* bu_seek ist der Offset von bu[]. Er gibt an, wo sich
  231.                          die "Lesemarke" in bu befindet, ab der der nächste
  232.                          Parameter gelsen wird. */
  233.  
  234. /* Erstmal einige nützliche Funktionen: */
  235.  
  236. /***************************************************************************
  237. ***                          read_next_digit()
  238. ***              Liest die nächste Nummer aus der prefs-Datei.
  239. ***              (Der nächste Parameter muß eine Nummer sein.)
  240. ***************************************************************************/
  241.  
  242. long read_next_digit()
  243. {
  244.     short number_cnt = 0;
  245.     char number[50];
  246.     
  247.     while( bu[bu_seek] != (char) 0x0D ) {
  248.         number[number_cnt] = bu[bu_seek];
  249.         bu_seek++;
  250.         number_cnt++;
  251.     }
  252.     number[number_cnt] = (char) 0x00;
  253.  
  254.     /*  Das (0x0D)(0x0A) muß übersprungen werden.
  255.      *  (Madhouse schreibt diese Sequenzen zwischen die Zeilen.)   */
  256.     bu_seek+=2;
  257.     
  258.     return strtol( number, 0, 10 );
  259. }
  260.  
  261. /***************************************************************************
  262. ***                          read_next_string()
  263. ***             Liest die nächste Zeichenkette aus der prefs-Datei.
  264. ***             (Der nächste Parameter muß eine Zeichenkette sein.)
  265. **************************************************************************/
  266.  
  267. void read_next_string( char *string, short maxlen )
  268. {
  269.     short text_cnt = 0;
  270.     
  271.     /* Ein Madhouse-Text beginnt aus technischen Gründen (Aha) mit "$".
  272.        Weil wir das "$" nicht benötigen, überspringen wir einfach das
  273.        nächste Zeichen. */
  274.     bu_seek++;
  275.     
  276.     while( (bu[bu_seek] != (char) 0x0D)  &&  (text_cnt < maxlen)  ) {
  277.         string[text_cnt] = bu[bu_seek];
  278.         bu_seek++;
  279.         text_cnt++;
  280.     }
  281.     
  282.     string[text_cnt] = (char) 0x00;
  283.     /* Jetzt haben wir den Text in string[]. */
  284.     
  285.     /*
  286.      *  Die (0x0D)(0x0A)-Sequenz überspringen.
  287.      */
  288.     
  289.     bu_seek+=2;
  290. }
  291.  
  292.  
  293.  
  294. /***************************************************************************
  295. ***                             read_prefs()
  296. ***                       Liest die Einstellungen.
  297. ***************************************************************************/
  298.  
  299. void read_prefs()
  300. {
  301.     short text_cnt = 0;
  302.     short number_cnt = 0;
  303.     BPTR f = NULL;
  304.     
  305.     f = Open( "RAM:Madhouse_Storage/prefs", MODE_OLDFILE );
  306.     if (f) {
  307.         Read( f, bu, sizeof( bu ) );
  308.         
  309.         /* Nun hat bu[] zum Beispiel so einen Inhalt:
  310.            "$Hello, this is a text(0x0D)(0x0A)2(0x0D)(0x0A)0(0x0D)(0x0A)
  311.            5(0x0D)(0x0A)RAM:Madhouse_Storage(0x0D)(0x0A)".
  312.            Die beiden Zeichen (0x0D) und (0x0A) sind zwischen jeder Zeile.
  313.            Hello,... ist unser erste Parameter. 2 ist der Zweite (die
  314.            Farbe des Textes), 0 der Dritte (Scrollen ja/nein), 5 ist
  315.            der Duration-Wert in Minuten und RAM:... ist der Pfad unseres
  316.            Verzeichnisses, falls wir eine Datei nachladen möchten.
  317.            Alle Madhouse-Strings beginnen mit "$".
  318.            Der erste Parameter wird in text[] verfrachtet, der Zweite kommt
  319.            in color, der Dritte in duration_sec und den Pfad brauchen wir
  320.            gar nicht. */
  321.         
  322.         /*
  323.          *   Erster Parameter (Text)
  324.          */
  325.          
  326.         read_next_string( text, 40 );
  327.         
  328.         /*
  329.          *   Zweiter Parameter (Color)
  330.          */
  331.         
  332.         color = read_next_digit();
  333.         
  334.         /*
  335.          *  Dritter Parameter (Scroll)
  336.          */
  337.         
  338.         scroll = read_next_digit();
  339.         
  340.         /*
  341.          *  Duration-Parameter.
  342.          */
  343.         
  344.         duration_sec = read_next_digit() * 60; /*Minuten -> Sekunden*/
  345.         
  346.         Close( f );
  347.     } else {     /* Der Blanker wurde nicht von Madhouse gestarten: Abbruch! */
  348.         exit(0);
  349.     }
  350. }        
  351.  
  352. /***************************************************************************
  353. ***                           write_stopblank()
  354. ***   Muß benutzt werden, wenn der Blanker durch den Anwender abgebrochen
  355. ***               wurde, und nicht durch den Duration-Wert.
  356. ***************************************************************************/
  357.  
  358. void write_stopblank()
  359. {
  360.     /* Wir müssen nur eine neue, leere Datei anlegen, schon weiß Madhouse
  361.        bescheit. */
  362.     
  363.     BPTR f;
  364.     f = Open( "RAM:Madhouse_Storage/stopblank", MODE_NEWFILE );
  365.     if( f )
  366.         Close( f );
  367. }
  368.  
  369. /***************************************************************************
  370. ***                              write_error()
  371. ***     Macht Madhouse klar, daß ein Fehler auftrat (und wie der Fehler
  372. ***            heißt) - darf nur EINMAL aufgerufen werden!
  373. ***************************************************************************/
  374.  
  375. void write_error( char *str )
  376. {
  377.     BPTR f;
  378.     char eol_marker = 0x0D;
  379.     
  380.     f = Open( "RAM:Madhouse_Storage/errors", MODE_READWRITE );
  381.     if( f ) {
  382.         Seek( f, 0, OFFSET_END );
  383.         Write( f, str, strlen(str) );
  384.         Write( f, &eol_marker, 1 );
  385.         Close( f );
  386.     } 
  387. }
  388.  
  389.  
  390.  
  391.  
  392.